home *** CD-ROM | disk | FTP | other *** search
/ MacHack 1997 / MacHack 1997.toast / Hacks / Hacks ’95 / Closure / Sources / PhotoshopHeaders / PIUtilities.h < prev   
Encoding:
C/C++ Source or Header  |  1995-06-24  |  7.6 KB  |  231 lines  |  [TEXT/MPS ]
  1. /* Plug-in module utility routines */
  2.  
  3. /* Copyright 1993-95 by Adobe Systems, Inc.  All rights reserved. */
  4.  
  5. /* The routines in this module provide a collection of utilities for accessing
  6.    the plug-in callback procedures and performing other useful tasks within
  7.    plug-ins. */
  8.  
  9. #ifndef __PIUtilities__
  10. #define __PIUtilities__
  11.  
  12. #include <stddef.h>
  13. #include <Types.h>
  14.  
  15. #include "PIGeneral.h"
  16.  
  17. /*****************************************************************************/
  18.  
  19. #ifdef __cplusplus
  20. extern "C" {
  21. #endif
  22.  
  23. /*****************************************************************************/
  24.  
  25. /* Check for the advance state procedure and warn if not present.             */
  26.  
  27. Boolean WarnHostAdvanceStateAvailable (AdvanceStateProc proc);
  28.  
  29. /*****************************************************************************/
  30.  
  31. /* The following routines provide shells around the buffer procs routines.
  32.    These routines allow us to allocate buffers from Photoshop's memory
  33.    without first telling Photoshop about it in the bufferSpace or maxSpace
  34.    parameter in the interface record.  This can be useful when we need
  35.    different sized buffers at different times. */
  36.  
  37. /* Are the buffer procs even available?  If not, the plug-in will have to
  38.    put up a warning dialog to indicate that it requires Photoshop 2.5 or
  39.    will have to work around this using the old memory management techniques
  40.    documented in earlier versions of the plug-in kit.  tooNew is set if the
  41.    procs version is newer than the plug-in.  The buffer procs version number
  42.    is unlikely to change, but it is wise to test it anyway.  If tooNew is
  43.    null, it will be ignored. */
  44.  
  45. Boolean HostBufferProcsAvailable (BufferProcs *procs, Boolean *tooNew);
  46.  
  47. /* The following dialog takes care of putting up the warning if the appropriate
  48.    version of the buffer procs is not available. */
  49.  
  50. Boolean WarnHostBufferProcsAvailable (BufferProcs *procs);
  51.  
  52. /* How much space is available for buffers?  This space may be fragmented. */
  53.  
  54. int32 HostBufferSpace (BufferProcs *procs); 
  55.  
  56. /* Allocate a buffer of the appropriate size setting bufferID to the ID
  57.    for the buffer.  If an error occurs, the error code will be returned
  58.    and bufferID will be set to zero. */
  59.  
  60. OSErr HostAllocateBuffer (BufferProcs *procs, int32 size, BufferID *bufferID);
  61.  
  62. /* Free the buffer with the given ID. */
  63.  
  64. void HostFreeBuffer (BufferProcs *procs, BufferID bufferID);
  65.  
  66. /* Lock the buffer and return a pointer to its contents. */
  67.  
  68. Ptr HostLockBuffer (BufferProcs *procs, BufferID bufferID, Boolean moveHigh);
  69.  
  70. /* Unlock the buffer.  Lock and unlock calls manipulate a counter, so they
  71.    must balance perfectly. */
  72.  
  73. void HostUnlockBuffer (BufferProcs *procs, BufferID bufferID);
  74.  
  75. /* The following routine allocates a buffer which is as tall as possible.  It
  76.    takes as parameters, the desired rowBytes, the minimum height, the
  77.    maximum height, and the fraction of the available buffer space to use
  78.    expressed as 1/numBuffers.  It sets the actual height and bufferID
  79.    parameters if successful. */
  80.  
  81. OSErr HostAllocateStripBuffer (BufferProcs *procs,
  82.                                int32 rowBytes,
  83.                                int16 minHeight,
  84.                                int16 maxHeight,
  85.                                int16 numBuffers,
  86.                                int16 *actualHeight,
  87.                                BufferID *bufferID);
  88.  
  89. /*****************************************************************************/
  90.  
  91. /* The following macros assume that gStuff is defined somewhere as a pointer
  92.    to the current interface record. */
  93.    
  94. #define WarnAdvanceStateAvailable() \
  95.     WarnHostAdvanceStateAvailable (gStuff->advanceState)
  96.     
  97. #define AdvanceState() \
  98.     (*(gStuff->advanceState)) ()
  99.  
  100. /*****************************************************************************/
  101.  
  102. /* Here are the routines for the buffer suite. */
  103.  
  104. #define BufferProcsAvailable(tooNew) \
  105.     HostBufferProcsAvailable (gStuff->bufferProcs, tooNew)
  106.  
  107. #define WarnBufferProcsAvailable() \
  108.     WarnHostBufferProcsAvailable (gStuff->bufferProcs)
  109.  
  110. #define BufferSpace() HostBufferSpace (gStuff->bufferProcs)
  111.  
  112. #define AllocateBuffer(size,bufferID) \
  113.     HostAllocateBuffer (gStuff->bufferProcs, size, bufferID)
  114.  
  115. #define FreeBuffer(bufferID) \
  116.     HostFreeBuffer (gStuff->bufferProcs, bufferID)
  117.  
  118. #define LockBuffer(bufferID,moveHigh) \
  119.     HostLockBuffer (gStuff->bufferProcs, bufferID, moveHigh)
  120.  
  121. #define UnlockBuffer(bufferID) \
  122.     HostUnlockBuffer (gStuff->bufferProcs, bufferID)
  123.  
  124. #define AllocateStripBuffer(rowBytes,minHeight,maxHeight,numBuffers,actualHeight,bufferID) \
  125.     HostAllocateStripBuffer (gStuff->bufferProcs,\
  126.                              rowBytes,\
  127.                              minHeight,\
  128.                              maxHeight,\
  129.                              numBuffers,\
  130.                              actualHeight,\
  131.                              bufferID)
  132.  
  133. /*****************************************************************************/
  134.  
  135. /* Similarly assuming gStuff to be defined, we define macros for testing
  136.    for abort and for updating the progress bar. */
  137.  
  138. #define TestAbort() ((*gStuff->abortProc) ())
  139.  
  140. #define UpdateProgress(done,total) ((*gStuff->progressProc) (done, total))
  141.  
  142. /*****************************************************************************/
  143.  
  144. /* Here is a corresponding set of routines and macros for the pseudo-resource
  145.    callbacks. */
  146.  
  147. Boolean HostResourceProcsAvailable (ResourceProcs *procs, Boolean *tooNew);
  148.  
  149. Boolean WarnHostResourceProcsAvailable (ResourceProcs *procs);
  150.  
  151. int16 HostCountPIResources (ResourceProcs *procs, ResType type);
  152.  
  153. Handle HostGetPIResource (ResourceProcs *procs, ResType type, int16 index);
  154.  
  155. void HostDeletePIResource (ResourceProcs *procs, ResType type, int16 index);
  156.  
  157. OSErr HostAddPIResource (ResourceProcs *procs, ResType type, Handle data);
  158.  
  159. #define ResourceProcsAvailable(tooNew)                                        \
  160.     HostResourceProcsAvailable (gStuff->resourceProcs, tooNew)
  161.     
  162. #define WarnResourceProcsAvailable()                                        \
  163.     WarnHostResourceProcsAvailable (gStuff->resourceProcs)
  164.     
  165. #define CountPIResources(type)                                                \
  166.     HostCountPIResources (gStuff->resourceProcs, type)
  167.     
  168. #define GetPIResource(type,index)                                            \
  169.     HostGetPIResource (gStuff->resourceProcs, type, index)
  170.     
  171. #define DeletePIResource(type,index)                                        \
  172.     HostDeletePIResource (gStuff->resourceProcs, type, index)
  173.     
  174. #define AddPIResource(type,data)                                            \
  175.     HostAddPIResource (gStuff->resourceProcs, type, data)
  176.  
  177. /*****************************************************************************/
  178.  
  179. /* And a set for the handle routines. */
  180.  
  181. Boolean HostHandleProcsAvailable (HandleProcs *procs, Boolean *tooNew);
  182.  
  183. Boolean WarnHostHandleProcsAvailable (HandleProcs *procs);
  184.  
  185. Handle HostNewHandle (HandleProcs *procs, int32 size);
  186.  
  187. void HostDisposeHandle (HandleProcs *procs, Handle h);
  188.  
  189. int32 HostGetHandleSize (HandleProcs *procs, Handle h);
  190.  
  191. OSErr HostSetHandleSize (HandleProcs *procs, Handle h, int32 newSize);
  192.  
  193. Ptr HostLockHandle (HandleProcs *procs, Handle h, Boolean moveHigh);
  194.  
  195. void HostUnlockHandle (HandleProcs *procs, Handle h);
  196.  
  197.  
  198. #define HandleProcsAvailable(tooNew)                                        \
  199.     HostHandleProcsAvailable (gStuff->handleProcs, tooNew)
  200.     
  201. #define WarnHandleProcsAvailable()                                            \
  202.     WarnHostHandleProcsAvailable (gStuff->handleProcs);
  203.     
  204. #define PINewHandle(size)                                                    \
  205.     HostNewHandle (gStuff->handleProcs, size)
  206.     
  207. #define PIDisposeHandle(h)                                                    \
  208.     HostDisposeHandle (gStuff->handleProcs, h)
  209.     
  210. #define PIGetHandleSize(h)                                                    \
  211.     HostGetHandleSize (gStuff->handleProcs, h)
  212.     
  213. #define PISetHandleSize(h,size)                                                \
  214.     HostSetHandleSize (gStuff->handleProcs, h, size)
  215.     
  216. #define PILockHandle(h,moveHigh)                                            \
  217.     HostLockHandle (gStuff->handleProcs, h, moveHigh)
  218.     
  219. #define PIUnlockHandle(h)                                                    \
  220.     HostUnlockHandle (gStuff->handleProcs, h)
  221.  
  222. /*****************************************************************************/
  223.  
  224. #ifdef __cplusplus
  225. } /* End of extern "C" block. */
  226. #endif
  227.  
  228. /*****************************************************************************/
  229.  
  230. #endif /* __PIUtilities__ */
  231.